לאחר הרצת התכנית יופיע בחלון הoutput הפלט הבא: run: ******************************* *****Welcome to Java!***** *******************************

Transcription

1 דוגמה 1: public class Hello { 2: public static void main(string[] args) { 3: System.out.println("*******************************"); 4: System.out.println("*******Welcome to Java!********"); 5: System.out.println("*******************************"); 6: } 7: } לאחר הרצת התכנית יופיע בחלון הoutput הפלט הבא: תרגיל כתה כתבו תכנית המציגה בחלון הפלט, בשורה אחת, מקום מגורים, גיל, צבע מועדף וכו('. run: ******************************* *****Welcome to Java!***** ******************************* את שמכם ובשורות הבאות פרטים על עצמכם )למשל דוגמה 1: import java.util.scanner; // import class Scanner 2: public class SayHello { 3: public static void main(string[] args) { 4: // create obeject to read input from screen 5: Scanner input = new Scanner(System.in); 6: String name; 7: // ask for user's name 8: System.out.println("What is your name?"); 9: name = input.next(); // read in user's name 10: System.out.println("Hello "+name); 11: } 12:} What is your name? לאחר ביצוע שורה 8 יופיע בחלון הפלט הטקסט: בעת ביצוע שורה 9, יפתח חלון הinput בתחתית המסך והתכנית תעצר ותמתין. המשתמש יכתוב את הנדרש בחלון הקלט והתכנית תמשיך רק לאחר שהמשתמש יקיש על מקש ה -.enter תרגיל 1 כתבו תכנית המבקשת המשתמש להקליד את מספר הטלפון שלו. המספר ייקלט כטקסט. התכנית תוסיף לתחילת המספר את הקידומת 9 ותוציא הודעה המציגה למשתמש את המספר עם הקידומת ותסביר למשתמש שזהו מספרו החדש. עליכם להגיש הדפסה של התכנית ושל הקלט והפלט באופן הבא: העתיקו את הקלט והפלט לחלון התכנית כך שיופיע אחרי התכנית והדפיסו על ידי בחירה בתפריט file בפקודה.print לאחר ההדפסה, מחקו מהחלון את הקלט והפלט כך שתישמר רק התכנית. 1

2 1: import java.util.scanner; 2: public class add2nums { 3: public static void main( String args[] ){ 5: Scanner readin = new Scanner(System.in); 6: int num1, num2, // the 2 numbers we want to add 7: sum; // the sum of the 2 numbers 8: // instruct user to enter 2 numbers 9: System.out.println("Enter 2 numbers a space between them?"); 10: num1 = readin.nextint(); // read in frist num 11: num2 = readin.nextint(); // read in second num 12: sum = num1 + num2; // add the numbers 13: System.out.println("The sum is "+ sum); 14: } 15: } : import java.util.scanner; 2: public class PhoneCall { 3: // Calculate the time a phone call will end given: start time and duration of call. 5: public static void main(string[] args) { 6: Scanner readin = new Scanner(System.in); 7: int hours, minutes, seconds, duration; 8: System.out.println("Enter start time as 3 integers, hours, minutes, seconds"); 9: // Read in star time 10: hours = readin.nextint(); // read in hours 11: minutes =readin.nextint(); // read in minutes 12: seconds = readin.nextint(); // read in seconds 13: System.out.println("Enter duration"); 14: duration = readin.nextint(); // read in duration 15: // calculate time of end of conversation 16: seconds = seconds + duration; 17: minutes = minutes + seconds / 60; 18: seconds = seconds % 60; 19: hours = hours + minutes / 60; 20: minutes = minutes % 60; 21: hours = hours % 24; 22: // Display result 23: System.out.println("End of conversation at " + hours + ":" + minutes + ":" + seconds); 24: } 25: } 2

3 תרגיל 2 כתבו תכנית הקולטת מהמשתמש מספר תלת-ספרתי ומציבה אותו במשתנה מספרי שלם )אחריות המשתמש לספק מספר העונה על הדרישות, התכנית יכולה להניח קלט תקין( התכנית תציב במשתנה מספרי אחר את המספר הנוצר מהיפוך הספרות של המספר שנקלט ותציג אותו על המסך. דוגמה: אם נקלט המספר 131 יש להציג על המסך את המספר 131. בזמן ההרצה, אל תכתבו כקלט, מספר המסתיים באפס אופן הדפסה: העתיקו את הפלט לחלון התכנית, מיד אחרי התכנית. הדפיסו ע"י בחירה בתפריט FILE בפקודה.PRINT DEBUGGING נוח לפתור שגיאות לוגיות ע"י הצגת תוכן משתנים בשלבים שונים של ההרצה. מעקב אחר תוכנם עשוי לעזור בפתרון הבעיה הלוגית. עשו זאת בעזרת ההוראה ניתן להוסיף במקומות שונים בתכנית את ההוראה: b System.out.println ( ) ; למשל כדי לעקוב אחר תוכן המשתנה System.out.println ( " b = " + b ) ; יש להסיר הוראות אלו לפני ההגשה : // Read student's mark in test, add 10% to marks below 70 2: // add 5% to marks 70 and above 3: import java.util.scanner; 4: public class IfExample { 5: public static void main(string[] args) { 6: Scanner myin = new Scanner(System.in); 7: double mark, newmark; 8: System.out.println("Enter your mark please"); 9: mark=myin.nextdouble(); 10: // determine final mark 11: if (mark <70 ){ 12: newmark = mark*1.1; 13: System.out.println("10% was added \nyour new mark is:"+newmark ); 14: } 15: else{ 16: newmark = mark*1.05; 17: System.out.println("5% was added \nyour new mark is:"+newmark ); 18: } 19: } 20: } 3

4 1: import java.util.scanner; 2: public class Grade { 3: // Read student's mark in test, 4: // determine student's grade 5: public static void main(string[] args) { 6: Scanner myin = new Scanner(System.in); 7: String ans; // answer to user 8: int mark ; // mark of student 9: System.out.println("Enter your mark please"); 10: mark=myin.nextint(); 11: ans=""; 12: // determine grade 13: if (mark < 0 mark >100 ) 14: ans="incorrect"; 15: else 16: if (mark < 50 && mark >= 0) 17: ans="fail"; 18: else if ( mark <=100 && mark >=50) 19: ans="pass"; 20: // display the results 21: System.out.println( "your grade is " + ans); 22: } 23: }

5 תרגיל 3 כתבו תכנית הקולטת שלושה מספרים שלמים. השלשה אמורה לייצג צלעות של משולש. עליכם להדפיס אחת מן המסקנות הבאות: א. המספרים אינם יכולים לייצג צלעות משולש מפני שאינם מקיימים את ההגדרה: סכום כל זוג צלעות במשולש גדול מן הצלע הנותרת. )דוגמה: השלשה 2,3,22 אינה מקיימת את ההגדרה משום ש 233 אינו גדול מ 22( ב. המספרים מייצגים צלעות משולש שווה צלעות )דוגמה ) 4 4, 4, ג. המספרים מייצגים צלעות משולש שווה שוקיים )דוגמה,4( 1, 1 ד. המספרים מייצגים צלעות של משולש רגיל )שאינו שווה צלעות ואינו שווה שוקיים( )דוגמה 1( 8,, 4 השתמשו בהוראות IF מקוננות ואל תבצעו בדיקות תקינות. שימו לב : כתבו את התכנית כך שתודפס רק המסקנה הנכונה ביותר לגבי השלשה, כלומר, אם המשולש הוא שווה צלעות יש להציג הודעה מתאימה למרות שמשולש כזה יענה גם על ההגדרה של משולש שווה שוקיים. ** בדקו שהתכנית נותנת תשובה נכונה עבור כל אחת מארבע האפשרויות הנ"ל. הציגו את הקלט והפלט )כפי שהוסבר בתרגילים קודמים( עבור אחת מהשלשות. 5

6 1: import java.util.scanner; // import class Scanner 2: public class WhileExample { 3: public static void main(string[] args) { 4: Scanner input = new Scanner(System.in); 5: String ans; 6: int times, i; 7: // Display "times" stars; 8: System.out.println("How many stars would you like?"); 9: times=input.nextint(); 10: ans=" Here are "+times+" stars: \n"; 11: i=1; 12: while (i<=times){ 13: ans=ans+"*" ; 14: i++ ; // i++ is the same as i=i+1 15: } 16: System.out.println(ans); 17: 18: // Display numbers from 1 to times; 19: ans=" Numbers from 1 to "+times+" are: \n"; 20: i=1; 21: while (i<=times ){ 22: ans=ans+i+", " ; 23: i++; 24: } 25: System.out.println(ans); 26: // Display even numbers from 2 to 20; 27: // ans=" Even numbers from 2 to 20 are: \n"; 28: // i= 29: // while ( ){ 30: // 31: // 32: // } 33: // System.out.println(ans); 34: } 35: } 6

7 //compute average of numbers entered by user 1: import java.util.scanner; 2: public class Average { 3: public static void main(string[] args) { 4: Scanner input = new Scanner(System.in); 5: int howmany, // number of numbers to be entered 6: sum, // sum of numbers 7: counter, // counter of numbers 8: number; // number entered 9: double average; // average of all numbers 10: // Initialization 11: sum = 0; 12: counter = 1; 13: System.out.println("Enter number of numbers"); 14: howmany=input.nextint(); 15: // Processing 16: while ( counter <= howmany ) { // loop "howmany" times 17: // read number from user as String and convert to type int 18: System.out.println("number please"); 19: number = input.nextint(); 20: // add number to sum 21: sum = sum + number; // shortcut: sum +=number; 22: // add 1 to counter 23: counter = counter + 1; // shortcut: counter++; 24: } // end of loop 25: // Termination 26: average = (double) sum / howmany; // perform real division 27: // display average of numbers 28: System.out.println( "Average is " + average ); 29: } 30: } 7

8 1: //compute average of numbers entered by user 2: import java.util.scanner; 3: public class Average1 { 4: public static void main(string[] args) { 5: Scanner input = new Scanner(System.in); 6: int sum, // sum of numbers 7: counter, // counter of numbers 8: number, // number entered 9: max ; // maximum number 10: double average; // average of all numbers 11: // Initialization 12: sum = 0; 13: counter = 0; 14: // Processing\ 15: // Read first number from user 16: System.out.println("Enter Integer, -1 to Quit"); 17: number = input.nextint(); 18: max = number; 19: while ( number!= -1 ) { 20: sum = sum + number; // add number to sum 21: counter = counter + 1; // add 1 to counter 22: if ( number > max ) // check if greater then max 23: max = number; 24: // Read next number from user 25: number = input.nextint(); 26: } 27: // Termination 28: if ( counter!= 0 ) { 29: average = (double) sum / counter; 30: // display average and max of numbers 31: System.out.println("Average is " + average 32: + "\n Maximum is " + max ); 33: } 34: else 35: System.out.println("No numbers were entered" ); 36: } 37: } 8

9 1: // Divide 2 whole numbers using subtraction and addtion only 2: import java.util.scanner; // import class Scanner 3: public class Div2Nums { 4: public static void main(string[] args) { 5: Scanner input = new Scanner(System.in); 6: int num, div, count, remain; 7: // read number and divider 8: System.out.println("Please enter whole number and divider"); 9: num= input.nextint(); 10: div=input.nextint(); 11: // calculate num divided by div 12: count=0; 13: remain=num; 14: while (remain>=div){ 15: count++; 16: remain=remain-div; 17: } 18: System.out.println( num+" divided by "+div+" is "+count+" remainder "+remain); 19: } 20: } : import java.util.scanner; 2: public class GuessNum { 3: public static void main(string[] args) { 4: Scanner input = new Scanner(System.in); 5: int number, guess; 6: String msg; 7: number=(int)(101*math.random()); // computer "selects" number 8: // read first guess from user 9: msg="let's play! Guess my number (between 0 and 100)"; 10: do { 11: System.out.println(msg); 12: guess= input.nextint(); 13: if (guess < number) 14: msg="my number is bigger, try again"; 15: else 16: if (guess > number) 17: msg="my number is smaller, try again"; 18: } while (guess!= number); 19: System.out.println( "You guessed it!!, "+number ); 20: } 21: } 9

10 תרגיל 4 כתבו תכנית הקולטת מספרים חיוביים שלמים ומציגה את המספר הקטן ביותר שנקלט )המינימום( ואת המספר השני הקטן ביותר. מספר המספרים אינו ידוע. רשימת המספרים תסתיים במספר שלילי. הריצו את התכנית לפחות שתי פעמים ובדקו שהתוצאות שקיבלתם נכונות. בהרצה הראשונה השתמשו בנתונים הבאים: בהרצה השניה השתמשו בנתונים הבאים: הציגו כפלט את התוצאות המתקבלות משתי הרצות אלו. אם הדבר מקל עליכם, מותר לכם להניח שהמשתמש יכניס לפחות 3 מספרים ושכל מספר יכול להופיע רק 1: import java.util.scanner; 2: public class ConstantsEx { 3: public static void main(string[] args) { 4: Scanner myread = new Scanner(System.in); 5: final int FROM_KG = 40, TO_KG = 100; 6: final double RATIO= ; 7: int kg = FROM_KG; 8: double pound; 9: System.out.println( " KILOGRAM\tPOUNDS") ; 10: while ( kg <= TO_KG ) { 11: pound = kg * RATIO; // convert kg to pound 12: System.out.println(" " +kg +"\t\t" + pound ); 13: kg = kg + 5; // increment the kg value 14: } 15: } 16: } פעם אחת. אין לבצע בדיקות תקינות! 11

11 2: public class ForExample{ 3: public static void main(string[] args){ 4: String s; 5: int i; 6: final int NUM = 10; 7: // Display NUM stars; 8: s=" Here are "+NUM+" stars: \n"; 9: for (i=1;i<=num;i++) 10: s=s+"*" ; 11: System.out.println( s); 12: // Display numbers from 1 to NUM; 13: s=" Numbers from 1 to "+NUM+" are: \n"; 14: for (i=1;i<=num;i++) 15: s=s+i+", " ; 16: System.out.println( s); 17: // Display even numbers from 2 to 2XNUM; 18: s=" Even numbers from 2 to "+2*NUM+" are: \n"; 19: for (i=2;i<=2*num;i=i+2) 20: s=s+i+", " ; 21: System.out.println( s); 22: } 23: } תרגיל כתה 12 מספרים ומחשבת ומציגה כפלט: כתבו תכנית הקולטת רק מבין 1 המספרים הראשונים, כמה מתחלקים ב- 3 ללא שארית 1. מה אחוז המספרים החיוביים 2. מהו הערך המקסימלי מבין הערכים השליליים בלבד. הניחו שהמספר הקטן ביותר שיכול להתקבל 3. הוא Among the first 5 numbers, 1 divides by 7 70%.are positive עבור הקלט הבא: 9 יהיה הפלט: -22 is the max of the negative numbers 11

12 1: // Check for perfect numbers 2: import java.util.scanner; 3: public class PerfectWhile{ 4: public static void main(string[] args){ 5: Scanner myread = new Scanner(System.in); 6: int number,sum,i; 7: // read the number 8: System.out.println(" Enter number please "); 9: number = myread.nextint(); 10: // Number is perfect if sum of its dividers 11: // (including 1 and not including the number itself) equals the number. 12: sum=0; 13: i=1; 14: while (i<number){ 15: if ((number%i) == 0 ) 16: sum = sum + i; 17: i++; 18: } // end of while 19: if (sum == number) 20: System.out.println(number + " is perfect" ); 21: else 22: System.out.println(number + " is not perfect"); 23: } 24: } for (i=1; i<number;i++) if ((number%i) == 0 ) sum = sum + i; // end of for 12

13 1: // read numbers from user until a negative number is entered 2: // or until 10 numbers have been read 3: import java.util.scanner; 4: public class UseBoolean { 5: public static void main(string[] args) { 6: Scanner readin = new Scanner(System.in); 7: int num; 8: boolean negative = false; 9: for (int i = 1; i <= 10 && negative == false; i++){ 10: System.out.println("Enter a number please"); 11: num = readin.nextint(); 12: if (num < 0) 13: negative = true; 14: } 15: //Did user enter a negative number? 16: if (negative == true) 17: System.out.println("Loop ended because a negative num was encountered"); 18: else 19: System.out.println("Loop ended because 10 nums were read"); 20: } 21: } for (int i = 1; i <= 10 ; i++){ System.out.println("Enter a number please"); num = readin.nextint(); if (num < 0){ negative = true; break; } } 13

14 1: // create multiplication table of 10 by 10 2: package kefel; 3: public class Kefel{ 4: public static void main(string[] args){ 5: 6: for (int i=1;i<=10;i++){ 7: for (int j=1; j<=10; j++) 8: System.out.print (i*j+"\t"); 9: System.out.println(); 10: } 11: } 12: } תרגיל כתה בחטיבת ביניים מסוימת יש 3 שכבות. בכל שכבה יש 4 כיתות. עליכם לטפל ב- 12 מספרים המיצגים את מספר התלמידים בכל כתה ולהציג את מספר התלמידים בכל אחת משלוש השכבות וכן את מספר התלמידים בכל בית הספר. המספרים יתקבלו בסדר הבא: 4 המספרים המיצגים את מספר התלמידים בכל אחת מ- 4 הכיתות של השכבה הראשונה, אח"כ 4 המספרים המיצגים את מספר התלמידים בכל אחת מ- 4 הכיתות של השכבה השניה ולבסוף 4 המספרים המיצגים את מספר התלמידים בכל אחת מ- 4 הכיתות של השכבה השלישית. במקום לקלוט את 12 המספרים מהמשתמש, הגרילו 12 מספרים בין 22 ל- 42. לדוגמה, אם המספרים שהוגרלו הם: 22,22,31,31,42,22,21,42,31,33,23,21 התכנית תציג: Sum for grade 7 :112 Sum for grade 8 :121 Sum for grade 9 :122 Sum for school : 311 תרגיל 1 כתבו תכנית הקולטת 2 מספרים שלמים חיוביים גדולים משתיים. המספרים מגדירים טווח. התכנית תציג על המסך את כל המספרים הראשוניים בטווח. לדוגמה: אם נקלטו המספרים 6 ו 24 יוצגו על המסך המספרים 3,11,13,13,19,23 אם נקלטו המספרים 21 ו 28 תופיע הודעה האומרת שאין בטווח זה מספרים ראשוניים. מספר ראשוני הוא מספר המתחלק, ללא שארית, רק באחד ובעצמו. הניחו קלט תקין, כלומר הניחו שקיבלתם שני מספרים חיוביים שלמים גדולים מ 2 ושהמספר הראשון שנקלט קטן מהמספר השני. אל תבצעו בדיקות תקינות! 14

15 // using JOptionPane class to read and write 1: import javax.swing.*; 2: public class ReadAndWrite { 3: public static void main(string[] args) { 4: JOptionPane.showMessageDialog(null,"Messages can be written this way too"); 5: String s; 6: int age; 7: double heightm, heighti; 8: s = JOptionPane.showInputDialog("Your name please"); 9: JOptionPane.showMessageDialog(null,"Hello "+s); 10: s = JOptionPane.showInputDialog("Your age please"); 11: age=integer.parseint(s); 12: JOptionPane.showMessageDialog(null,"You were born in "+(2005-age)); 13: s = JOptionPane.showInputDialog("Please enter your height in meters"); 14: heightm=double.parsedouble(s); 15: heighti = (heightm*100) * ; 16: JOptionPane.showMessageDialog(null,"Your height is "+heighti+" feet'"); 17: } 18: } 1: // Recieve number between 1 and 5 and write the number as a word 2: import javax.swing.*; 3: public class SwitchEx { 4: public static void main(string[] args) { 5: String schoice; 6: int choice; 7: schoice= JOptionPane.showInputDialog ("Write a number between 1 and 5"); 8: choice = Integer.parseInt(sChoice); 9: switch (choice) { 10: case 1: JOptionPane.showMessageDialog(null,"one"); break; 11: case 2: JOptionPane.showMessageDialog(null,"two"); break; 12: case 3: JOptionPane.showMessageDialog(null,"three"); break; 13: case 4: JOptionPane.showMessageDialog(null,"four"); break; 14: case 5: JOptionPane.showMessageDialog(null,"five"); break; 15: default: JOptionPane.showMessageDialog(null,"Not a valid choice"); 16: } // end of switch 17: } 18: } 15

16 String words ; words = This is an example ; שיטות של המחלקה String )רשימה חלקית( לצורך הדגמה נניח שהוגדרה ואתחלה המחרוזת הבאה: מחזירה את אורך המחרוזת )מספר התוים(. דוגמה: words.length(); int =x יציב ב X את המספר 18 - length () )1 index) - charat (int מקבלת מספר שלם index ומחזירה את התו הנמצא במקום ה index של המחרוזת. )האינדקס של המקום הראשון הוא 2(. דוגמה: ; words.charat(1) char c = תציב את הערך h במשתנה.c )2 ch) indexof (char מקבלת תו ch ומחזירה את האינדקס של המופע הראשון של התו במחרוזת. אם התו לא נמצא במחרוזת - מחזירה 1-. דוגמה: ; ('s') int j = words. indexof תציב את הערך 3 במשתנה.j - מקבלת תו ch lastindexof (char ch) התו במחרוזת. דוגמה: ; = words. lastindexof ('s') מחזירה את האינדקס של המופע האחרון של int j תציב את הערך.j במשתנה 6 2 מקבלת אינדקסים ומחזירה אוביקט מסוג החל מהתו במקום substring (int index1, int index2) String המכיל תת-מחרוזת של המחרוזת באוביקט הנוכחי - עד לתו במקום.index2-1,index1 דוגמא: ; 7) (5, words.substring String s1 = תציב בs1 את המחרוזת "is" )3 )4 )1 String המכיל תת- מקבלת אינדקס ומחזירה אוביקט מסוג index) substring (int ועד לסוף index החל מהתו במקום - מחרוזת של המחרוזת באוביקט הנוכחי המחרוזת. דוגמא: ; (11) words.substring String s1 = תציב בs1 את המחרוזת "example" )6 3( (s equals (String מקבלת מחרוזת ומחזירה את הערך מכילים את אותה המחרוזת. true אם מחזירה את הערך (s2 if(s1 == שימו לב שההוראה: אוביקט. לבדיקה אם המחרוזת s מכילה "yes" דוגמא: true אם האוביקט והפרמטר s1 ו s2 מתיחסים לאותו נכתוב:... if(s.equals( yes ( equalsignorecase (String s) והפרמטר זהים פרט ל דוגמא: מקבלת מחרוזת ומחזירה את הערך case )גודל האותיות(. true אם האוביקט לבדיקה אם המחרוזת s מכילה "yes" או YES" או Yes" נכתוב:... ( yes ( if(s. equalsignorecase )8 16

17 1: //Using String methods 2: import javax.swing.joptionpane; 3: public class PlayWithStrings { 4: public static void main(string[] args) { 5: String ans = new String(""); 6: String fullname= JOptionPane.showInputDialog("What is your name?"); 7: int len = fullname.length(); 8: ans="num of characters in name is: "+len+" \n"; 9: char first = fullname.charat(0); 10: ans = ans + "First letter of first name is: "+first+" \n"; 11: int firstspace = fullname.indexof(' '); 12: ans = ans + "First space in name is character: "+firstspace+" \n"; 13: int lastspace = fullname.lastindexof(' '); 14: if (firstspace == lastspace) 15: ans = ans + "Only one space in Name \n"; 16: else 17: ans = ans + "More than one space in Name \n"; 18: String lastname = fullname.substring(lastspace); 19: ans = ans + "Last name is: " + lastname + " \n"; 20: String firstname = fullname.substring(0,firstspace); 21: ans = ans + "First name is: " + firstname+ " \n"; 22: if (fullname.equals("yosi Cohen")) 23: ans = ans + "Hi Yosi Cohen \n"; 24: else 25: ans = ans + "You are not Yosi Cohen \n"; 26: JOptionPane.showMessageDialog(null,ans); 28: } 29:} 17

18 תרגיל 6 כתבו תכנית אשר קולטת מספרים רבים מהמשתמש, בחלון אחד )בעזרת המחלקה (. JOptionPane התכנית תסכום את המספרים שנקלטו ותציג את סכומם. הסבר: התכנית תבקש מהמשתמש להקליד מספרים שלמים כאשר כל מספר מופרד מהמספר שאחריו על ידי רווח. המספרים יקלטו, לתוך משתנה מסוג מחרוזת. לדוגמה: פירוק המחרוזת למספרים יעשה באמצעות לולאה. בכל מעבר בלולאה יתבצעו הפעולות הבאות: זיהוי היכן )באיזה תו( מסתיים המספר הראשון במחרוזת, שליפה של תת המחרוזת המתחילה בתו הראשון של המחרוזת ומסתיימת ברווח הראשון והצבתה במחרוזת עזר, המרת מחרוזת העזר למספר והצבתו במשתנה מספרי, הוספת המספר לסכום המספרים, הסרת תת המחרוזת המכילה את המספר הראשון )והרווח( מן המחרוזת המקורית. שימו לב: כיצד תדעו שהגעתם למספר האחרון במחרוזת? יש לטפל במספר האחרון באופן מיוחד. כתבו את התכנית כך שקל יהיה להתאים אותה לקליטת N מספרים ולא מספר מספרים ידוע מראש. הקלטים והפלטים מודפסים ע"י לחיצה על PRINT SCREEN 3 ALT כאשר החלון המבוקש מופיע, הדבקה.PAINT והדפסת החלון PAINT בחלון ) PASTE ( 1: import javax.swing.joptionpane; 2: public class Menus { 3: public static void main(string[] args) { 4: String schoice, sans, s; 5: int choice, num, ans; 6: boolean tryguess; 7: tryguess=false; 8: do { 9: schoice= JOptionPane.showInputDialog 10: ("Please choose: 1=Guess num 2=Multiplication question 3=favorite animal 4=Quit"); 11: choice = Integer.parseInt(sChoice); 12: switch (choice){ 13: case 1: 14: tryguess=true; 15: sans= JOptionPane.showInputDialog ("Guess my num (between 0 and 3)"); 16: ans = Integer.parseInt(sAns); 17: num=(int)(math.random()*4); 18: if (ans==num) 19: JOptionPane.showMessageDialog(null,"You guessed it!"); 20: else 21: JOptionPane.showMessageDialog(null,"No, it's "+num); 22: break; 18

19 23: case 2: 24: int a=(int)(math.random()*10); 25: int b=(int)(math.random()*10); 26: sans= JOptionPane.showInputDialog ("How much is "+a+" X "+b+"?"); 27: ans = Integer.parseInt(sAns); 28: if (ans==a*b) 29: JOptionPane.showMessageDialog(null,"correct!"); 30: else 31: JOptionPane.showMessageDialog(null,"No, it's "+a*b); 32: break; 33: case 3: 34: sans = JOptionPane.showInputDialog("What is your favorite animal?"); 35: if (sans.equals("dog")) 36: JOptionPane.showMessageDialog(null,"Hey, we like the same animal!"); 37: else 38: JOptionPane.showMessageDialog(null,"That's nice!"); 39: break; 40: case 4: 41: if (tryguess == true) 42: JOptionPane.showMessageDialog(null,"BYE"); 43: else 44: JOptionPane.showMessageDialog(null,"Next time try to guess my num"); 45: break; 46: default: JOptionPane.showMessageDialog(null,"Not a valid choice"); 47: } // end of switch 48: } // end of do 49: while (choice!=4); 50: } 51: } 19

20 1: public class Methods1{ 2: public static void main(string[] args){ 3: // Using a method to print stars 4: System.out.println( "I will print stars"); 5: stars(); 6: System.out.println( "and again stars"); 7: stars(); 8: } 9: public static void stars() 10: { 11: System.out.println("***"); 12: } 13: } : import java.util.scanner; 2: public class Methods2{ 3: public static void main(string[] args){ 4: Scanner input = new Scanner(System.in); 5: int num; 6: // Using a method to print the number of stars user wants 7: System.out.println( "Please enter number of stars" ); 8: num=input.nextint(); 9: stars(num); 10: System.out.println("I will print 3 stars"); 11: stars(3); 12: } // of method main 13: public static void stars(int num){ 14: String s=""; 15: for (int i = 1;i<=num;i++) 16: s=s+"*"; 17: System.out.println(s); 18: } // of method stars 19: } // of class methods2 21

21 1: import java.util.scanner; 2: public class FindMin { 3: public static void main( String args[] ){ 4: Scanner myin = new Scanner(System.in); 5: int num1, num2, num3, min; 6: // read in the numbers from user 7: System.out.println("Please enter 3 whole numbers "); 8: num1 = myin.nextint(); 9: num2 = myin.nextint(); 10: num3 = myin.nextint(); 11: // call the minimum method 12: min = mini( num1, num2, num3 ); 13: // display the result 14: System.out.println("The minimum is " + min ); 15: } 16: // minimum method definition 17: public static int mini( int x, int y, int z ){ 18: int temp; 19: if ( x < y) 20: temp = x; 21: else 22: temp = y; 23: if ( z < temp ) 24: return z; 25: else 26: return temp; 27: } 28: } 21

22 1: //find all prime numbers in range given by user 2: import java.util.scanner; 3: public class Primes { 4: public static void main ( String arg[] ) { 5: Scanner readstuff = new Scanner(System.in); 6: int fromnum, tonum; 7: System.out.println("Enter your range (2 numbers)"); 8: fromnum = readstuff.nextint(); 9: tonum = readstuff.nextint(); 10: String reply="primes in range "+fromnum + " to "+tonum + " are:\n"; 11: for ( int i = fromnum; i <= tonum; i++ ) 12: if ( isprime ( i ) ) 13: reply = reply+(" " + i ); 14: // display output 15: System.out.println(reply); 16: } 17: public static boolean isprime ( int number ){ 18: double sqrt = Math.sqrt( number ); // compute the square root one time only! 19: for ( int j=2; j <= sqrt; j++ ){ 20: if ( number % j == 0 ) 21: return false; 22: } 23: return true; 24: } 25: } כתה 1. public static void tworandnums(){ } 2. public static void tworandnums(int tonum){ } תרגיל כתבו מחלקה ובה השיטות הבאות: השיטה מציגה על המסך שני מספרים אקראיים שלמים שונים בין 1 לבין 12. השיטה מציגה על המסך שני מספרים אקראיים שלמים שונים בין 1 לבין tonum 3. public static void tworandnums(int fromnum,int tonum){ } השיטה מציגה על המסך שני מספרים אקראיים שלמים שונים בין fromnum לבין tonum 4. public static void fibo(int numbers){ } השיטה מציגה על המסך את numbers המספרים הראשונים בסדרת פיבונאצ'י. סדרת פיבונאצ'י היא סדרת מספרים שאיבריה הראשונים הם 1 ו- 1, וכל איבר אחר בה שווה לסכום שני קודמיו. לדוגמא, 12 האיברים הראשונים של הסידרה הם: 1,1,2,3,1,8,13,21,34, public static void drawrectangle (int rows, int cols){ } השיטה מציירת מלבן המורכב מכוכביות ובו rows שורות ו- cols עמודות. לדוגמה אם מפעילים את השיטה כך: 22

23 drawrectangle(3,5) ***** ***** ***** drawrectangle(4,4) **** **** **** **** מקבלים על המסך: ואם מפעילים את השיטה כך: מקבלים על המסך: 6. public static void drawtriangle (int rows){ } השיטה מציירת משולש המורכב מכוכביות ובו rows שורות. לדוגמה אם מפעילים את השיטה כך: drawtriangle (5) מקבלים על המסך: * ** *** **** ***** 7. public static void countletterinsentence(string sentence, char let){ } השיטה מקבלת משפט ואות ומדפיסה את מספר הפעמים שהאות let מופיעה במשפט.sentence tworandnums(); tworandnums(100); tworandnums(20,40); fibo(15); drawrectangle(3,5) drawtriangle (5); כתבו את השיטה main והפעילו מתוכה את השיטות שכתבתם באופן הבא: countletterinsentence("how are you today?",'o'); countletterinsentence("how are you today?",'a'); countletterinsentence("how are you today?",'w'); countletterinsentence("how are you today?",'x'); את השיטה 3 הפעילו כך: בתרגיל זה אין צורך לקרוא קלט מן המסך. הדפיסו את הפלט על המסך בעזרת System.out הגישו הדפסה של המחלקה שכתבתם ושל הפלט. 23

24 תרגיל 3 כתבו תכנית המאפשרת לילד לבחון את עצמו בחשבון. question() public static boolean התכנית תכיל שיטה בשם השיטה תבצע את הפעולות הבאות: תבקש מהמשתמש לבחור אחת מפעולות החשבון הבאות: 3 )חיבור( )חיסור( * )כפל( או / )חילוק בשלמים(. Math של המחלקה random תיצור 2 מספרים אקראיים שלמים בין 1 לבין 12 תוך שימוש בשיטה תציג למשתמש את התרגיל שעליו לבצע )המספר הראשון אחריו הפעולה שנבחרה ואחר כך המספר השני( ותבקש את תשובתו switch תשווה את התוצאה שהתקבלה מהמשתמש עם התוצאה הנכונה )השתמשו בהוראה לחישוב התוצאה הנכונה( אם התוצאה נכונה השיטה תציג הודעה משמחת ותחזיר לשיטה הקוראת את הערך,true אם התוצאה שגויה השיטה תציג את התוצאה הנכונה יחד עם הודעה מתאימה ותחזיר לשיטה הקוראת את הערך false השיטה main תכיל לולאה שתקרא שוב ושוב לשיטה, question לאחר הקריאה הראשונה, ישאל המשתמש אם הוא רוצה להמשיך, אם תשובתו חיובית, הלולאה תתבצע שוב, אם תשובתו שלילית, הלולאה תפסק. לאחר סיום הלולאה התכנית תציג את מספר השאלות שנשאל המשתמש ומספר תשובותיו הנכונות. הערה: ניתן לבצע חלוקה ממשית בתרגילי החילוק אולם יש לקחת בחשבון חוסר דיוק בתשובה, למשל 12/3 שווה 3.3 או

25 1: import javax.swing.*; 2: public class Cat{ משתני מחלקה 3: private String color; 4: private String meow; 5: private double weight; 6: public Cat(){ 7: color="gray"; בנאי 8: meow="meowww"; אחד 9: weight=1.0; 10: } 11: public Cat(String col,double w){ 12: color=col; בנאי שני 13: meow="meoww"; 14: weight=w; 15: } 16: public void eat(double food){ 17: weight=weight+food/10; 18: } 19: public void lose (double loss){ 20: if (loss>0) 21: weight=weight-loss; 22: } 23: public void speak(){ 24: JOptionPane.showMessageDialog(null,meow); 25: } 26: public double yourweight (){ 27: return weight; 28: } 29: } : import javax.swing.*; 31: public class GoodCat{ 32: public static void main(string[] args){ 33: Cat mitzi = new Cat(); 34: Cat ziva = new Cat ("Black",2.5); 35: mitzi.eat(0.5); 36: double mishkal = mitzi.yourweight(); 37: JOptionPane.showMessageDialog(null,"Cat's weight is "+mishkal); 38: ziva.speak(); 39: } 40: } 25

26 1: // Definition of class Die by Ori Keren 2: public class Die { 3: private int value; // die current value 4: private int max; // how many faces does the die have 5: // constructor 6: public Die(int m){ 7: max = m; 8: roll(); // roll the die one time.. 9: } 10: public void roll(){ 11: value = (int)(max * Math.random()+1); 12: } 13: public int getval(){ 14: return value; 15: } 16: public boolean is_equal(die other_die){ 17: if (value == other_die.value) 18: return true; 19: else 20: return false; 21: } 22: // clone current die; 23: public Die clone_die(){ 24: Die new_die = new Die(max); 25: new_die.value = value; 26: return new_die; 27: } 28: } 26

27 1: public class dice { 2: public static void main( String args[] ){ 3: int sum; 6: Die die1, die2; // declare 2 dice 7: // initialize the dice 8: die1 = new Die(6); 9: die2 = new Die(6); 11: die1.roll(); 12: die2.roll(); 13: if(die1.getval()+die2.getval()>9 ) 14: System.out.println("Sum of dice is greater than 9"); 15: else 16: System.out.println("Sum of dice is less than or equal to 9"); 18: if (die1.is_equal(die2)) 19: System.out.println("Both dice show the same number"); 20: else 21: System.out.println("Dice show different numbers"); 22: } 23: } 1: public class freq { 2: public static void main(string[] args) { 3: // creat a 3 sided die 4: Die d1 = new Die(3); 5: int mone1=0, mone2=0, mone3=0; 6: // roll die 100 times, count how many times each number came up 7: for(int i = 1 ; i <= 100 ; i++){ 8: d1.roll(); 9: switch (d1.getval()){ 10: case 1: mone1++; 11: break; 12: case 2: mone2++; 13: break; 14: case 3: mone3++; 15: } // of switch 16: } // of for 17: System.out.println("number freq\n1\t"+mone1+"\n2\t"+mone2+"\n3\t"+mone3); 18: } 20: } 27

28 תרגיל 8 הכינו מחלקה יחיד מסוג Rectangle לייצוג מלבן. משתני המחלקה הם אורך המלבן ורוחב המלבן )מספרים שלמים( וערך char והוא הצורה באמצעותה ניתן לצייר את המלבן )הסבר בהמשך(. שימו לב: למען הנוחות הוגדר צד אחד של המלבן בשם אורך וצד שני בשם רוחב למרות שיתכנו מקרים בהם ה"אורך" יהיה קצר מה"רוחב". הכינו שני :constructors.1.2 )1 ללא פרמטרים אשר יאתחל את האורך והרוחב לערך 1 ואת המשתנה השלישי לסימן *. בעל 3 פרמטרים, אחד לכל משתנה. הכינו את השיטות הציבוריות public) ) הבאות: public void drawrect() השיטה מדפיסה את המלבן בחלון בעזרת התו במשתנה השלישי. לדוגמה: עבור אורך 2 רוחב 1 והסימן # תדפיס השיטה: public int getlength() ##### ##### )2 השיטה מחזירה את אורך המלבן public void mult(int times) )3 השיטה מקבלת מספר שלם כפרמטר ומשנה את אורכו ורוחבו של המלבן כך שיהיו times כפול האורך והרוחב המקורי. public void biggest (Rectangle mal1, Rectangle mal2) )4 השיטה מקבלת כפרמטרים שני מלבנים, ומשנה את מימדי המלבן עליו מופעלת השיטה כך שיהיו בעלי האורך הגדול מבין שני האורכים של המלבנים והרוחב יהיה הגדול מבין שני המלבנים. השיטה אינה משנה את התו )הצורה( של המלבן. דוגמה: אם מתקבל המלבן 3X1 ו 2X12 יש להציב אורך 3 וברוחב 12. כתבו מחלקה בשם tar8 ובה בדקו המחלקה הנ"ל באופן הבא: הגדירו את 3 האובייקטים הבאים מסוג מלבן: אורך רוחב בעזרת השיטה שכתבתם, הדפיסו את מלבן צורה X הראשון. עם פרמטר שהוא אורך המלבן השני. מימדי המלבן השלישי בעזרת השיטה השלישית, הגדילו את הדפיסו את המלבן המתקבל. הפעילו על המלבן השלישי את השיטה biggest כשהפרמטרים הם המלבן הראשון והמלבן השני. והדפיסו את המלבן המתקבל. הדפיסו והגישו את שתי המחלקות ואת הפלט. שדכו דפים. 28

29 מערכים משתנה מסוג מערך ניתן להציג באופן הבא: למערך שם אחד ולכל תא במערך יש מצין )אינדקס(. הגדרת המערך: דוגמה להגדרת המערך הנ"ל: ואח"כ הקצאת מקום בזיכרון למערך: דוגמה להקצאת מקום בזיכרון: ; שם המערך ][ סוג אברי המערך int [] numbers; ; ]מספר תאי המערך[ סוג תאי המערך = new שם המערך numbers = new int [10]; הוגדר מערך בשם numbers בעל 12 תאים הממוספרים מ 2 עד. 9 התאים יכילו ערכים מספריים שלמים. numbers[3]=15; numbers[0]=3; numbers[9]=-4; הצבת ערכים בתאי המערך: לאחר ביצוע ההוראות הנ"ל יראה המערך כך: int i = 2; numbers[i]=10; numbers[i+1]=19; בדרך כלל יהיה האינדקס משתנה ולא קבוע: לאחר ביצוע ההוראות הנ"ל יראה המערך כך: for (i=0; i<10;i++) { numbers[i]=i+3; { דוגמה נוספת: לאחר ביצוע ההוראות הנ"ל יראה המערך כך: !! אסור לחרוג מהתחום שהוגדר עבור המערך!! מותר להגדיר מערך ולהקצות לו זיכרון ולאתחל אותו באופן הבא: int numbers [] = {5, 8,8,4,9, 67, 100, 0, -6, 5}; הוגדר מערך של מספרים שלמים בגודל 12 ובו הערכים הנ"ל. 29

30 1: import java.util.scanner; 2: public class Arrays1{ 3: public static void main(string[] args){ 4: Scanner read = new Scanner(System.in); 5: final int STUDENTS=5; 6: int sum=0,i,count=0; 7: double average; 8: String s; 9: int [] marks; 10: marks=new int[students]; 11: System.out.println("Please enter "+STUDENTS+" grades"); 12: for (i=0;i<students;i++){ 13: marks[i] = read.nextint(); 14: sum=sum+marks[i]; 15: } 16: average=(double)sum/students; 17: s="average is: "+average+"\nabove average grades:\n"; 18: for (i=0;i<students;i++) 19: if(marks[i]>average){ 20: count++; 21: s=s+marks[i]+" "; 22: } 23: s=s+"\n "+count+" grades"; 24: System.out.println(s); 25: } 26: } Class TestArrays : import java.util.scanner; 1: public class TestArrays2 { 2: public static void main(string[] args){ 3: Arrays2 ar = new Arrays2(20); 4: ar.displaynums(); 5: int sum = ar.sumnums(); 6: int max = ar.findmax(); 7: int cell = ar.findplaceofmax(); 8: System.out.println("Sum="+sum+" Max="+max+" in cell "+cell); 9: } 10: } 31

31 1: public class Arrays2{ 3: private int [] maar; 5: public Arrays2 (int size){ // constructor 6: maar=new int[size + 1]; 7: // enter numbers into array from cell 1 to cell size 8: for (int i=1;i<=size;i++) 9: maar[i]=(int) (Math.random()*100) ; 10: } 12: 13: public void displaynums() { //Display numbers 14: String s=(" Numbers are:\n"); 15: for (int i=1;i<maar.length;i++) 16: if (i% 4 ==0) 17: s=s+maar[i]+"\n"; 18: else 19: s=s+maar[i]+"\t"; 20: System.out.println(s); 21: } 23: public int sumnums (){ // find sum of numbers in array 24: int sum =0; 25: for (int i=1;i<maar.length;i++) 26: sum=sum+maar[i]; 27: return sum; 28: } 30: public int findmax(){ //find maximum of numbers in array 31: int max = -1; 32: for (int i=1;i<maar.length;i++) 33: if (maar[i]>max) 34: max=maar[i]; 35: return max; 36: } 38: public int findplaceofmax(){ //find place of maximum of numbers in array 39: int place=1; 40: int max=maar[1]; // max variable is not necessary 41: for (int i=2;i<maar.length;i++) 42: if (maar[i]>max){ 43: max=maar[i]; 44: place=i; 45: } 46: return place; 47: } 48: } 31

32 1: public class FreqArray { 2: public static void main(string[] args) { 3: // creat a 6 sided die 4: Die d1 = new Die(6); 5: int [] mone = new int [7]; 6: // roll die 100 times, count how many times each number came up 7: for(int i = 1 ; i <= 100 ; i++){ 8: d1.roll(); 9: int face =d1.getval(); 10: mone[face]=mone[face]+1; 11: } // of for 12: System.out.println("Number freq"); 13: for (int i = 1; i <= 6; i++) 14: System.out.println(i+"\t"+mone[i]); 15: } 16: } 32

33 18: public class Palyndrom { 19: private String word; 20: public Palyndrom(String s) { // constructor 21: word = s; 22: } 23: public boolean check(){ // check if word is a palyndrom 24: char [] letters; 25: letters = word.tochararray(); 26: for (int i = 0, j =word.length()-1; i<j ; i++,j--) 27: if (letters[i]!=letters[j]) 28: return false; 29: return true; 30: } 31: } 33

34 תרגיל 9 הכינו מחלקה.MyArray משתנה המחלקה הוא מערך של מספרים שלמים בשם : nums private int [] nums; הכינו בנאי ( constructor ) בעל פרמטר אחד אשר יקבע את גודל המערך. הבנאי יצור את המערך בגודל המבוקש ויציב בו מספרים אקראיים שלמים בטווח 2 עד 122. הכינו את השיטות הציבוריות public) ) הבאות: public void displayarray().1 השיטה מציגה את אברי המערך בחלון. public int countunder (int number).2 השיטה מחזירה את מספר המספרים במערך הקטנים מ number" " )הפרמטר שהועבר(. public boolean sidraola (int upto).3 השיטה מחזירה TRUE אם המספרים במערך עד לתא upto מהוים סדרת מספרים עולה )כל מספר גדול מקודמו (, אחרת היא מחזירה.FALSE public boolean findnumber (int number).4 השיטה מחפשת את המספר number )שהועבר כפרמטר( במערך ומחזירה TRUE אם הוא נמצא במערך, FALSE אחרת. public void swap (int i, int j).1 השיטה מחליפה את תוכן התאים i ו- j. public void deleteandtrim (int i).6 השיטה מוחקת את תוכן התא i ומעתיקה את תוכן התאים שאחרי התא i אל התא i ואילך. לבסוף היא מוסיפה אפס בתא האחרון. לדוגמא, עבור המערך והפרמטר 2 השיטה תשנה את ערכי המערך כך שיתקבל המערך: כלומר היא תמחק את תוכן תא 2 שהוא 3 ותעביר את תוכן תא שלוש למקום מספר שתיים, את תוכן תא 4 למקום מספר 3 ותציב 2 בתא האחרון. כתבו מחלקה בשם Tar9 ובה השיטה main הבודקת את המחלקה באפן הבא: מגדירה אובייקט מסוג.MyArray מפעילה כל אחת מ 6 השיטות הנ"ל ומעבירה את הפרמטרים הבאים: עבור שיטה 2 יש להעביר 12 כפרמטר, עבור השיטה 3 יש להעביר 2 כפרמטר, עבור שיטה 4 יש להעביר 33 כפרמטר, עבור שיטות 1 ו- 6 העבירו פרמטרים כרצונכם. לאחר הפעלת שיטות 1-4 יש להציג בחלון את התוצאות שהתקבלו. לאחר הפעלת השיטה 1, יש להוציא הודעה ובה כתוב "1" ולהפעיל שוב את שיטה. 1 לאחר הפעלת השיטה 6, יש להוציא הודעה ובה כתוב "6" להפעיל בפעם האחרונה את שיטה 1. הדפיסו והגישו את שתי המחלקות ואת הפלט. שדכו דפים. 34

35 int mat [] []; mat = new int [3] [5]; int mat [] [] = {{1,5,3,7,8}, {6,6,6,6,6}, {78,34,56,2,0}}; מערכים דו-ממדיים הגדרה: הקצאת זיכרון: או הגדרה והקצאת זיכרון ואיתחול: ההגדרה הנ"ל )ללא אתחול( יוצרת את המערך הדו-ממדי הבא בעל 3 שורות ו 1 עמודות )המספר הראשון קובע מספר שורות והמספר השני קובע מספר עמודות(: הצבת ערך בתא: 11; = [4] [1] mat הוראה זו מציבה 11 בתא הנמצא בשורה מספר 1 )השורה השנייה( ובעמודה מספר ארבע )עמודה חמישית(. לאחר ההצבה יראה המערך כך: התייחסות לתא מסוים נעשית באמצעות שם המערך, אחריו מספר השורה ואחריו מספר העמודה בסוגריים מרובעים. כדי לעבור על כל תאי מערך דו-ממדי, נוח להשתמש בלולאות כפולות. בדוגמה הבאה עוברים על אברי המערך הנ"ל ובודקים אם יש בו אברים שליליים: for (int i=0; i<3; i++) for (int j=0; j<5; j++) if (mat[i][j] < 0 ) System.out.println( " There is a negative number " ); : // Students' grades in tests. 2: import java.util.scanner; 3: public class UseMatrix { 4: public static void main(string[] args) { 5: Scanner s = new Scanner(System.in); 6: // Use class Matrix to hold student's grades in tests. 7: System.out.println("Please enter number of students and number of tests"); 8: int students = s.nextint(); 9: int tests = s.nextint(); 10: Matrix grades = new Matrix(students, tests); 11: // Read in student's grades 35

36 12: for (int i = 0; i <students; i++){ 13: System.out.println("please enter grades for student "+i); 14: for (int j = 0 ; j < tests; j++){ 15: int g = s.nextint(); 16: grades.enternum(i, j, g); 17: } 18: } //Display a student's average 20: System.out.println("Whose average do you need?"); 21: int stud = s.nextint(); 22: int sumforstud=grades.sumofrow(stud); 23: double avgstud = (double)(sumforstud)/tests; 24: System.out.println("Average of grades for student "+stud+" is "+avgstud); 25: // Display the average for a certain test 26: System.out.println("Average of which test do you need "); 27: int test = s.nextint(); 28: int sumfortest=grades.sumofcol(test); 29: double avgtest = (double)(sumfortest)/students;; 30: System.out.println("Average for test "+test+" is "+avgtest); 31: } 32: } : // Using a 2 dimensional array 2: public class Matrix { 3: private int [][] mat; 4: public Matrix(int row, int col){ 5: mat=new int[row][col]; 6: } 7: public void enternum (int r, int c, int num){ 8: mat[r][c] = num; 9: } 10: public int sumofcol (int col){ // Compute sum of Column 11: int sum=0; 12: for (int r=0;r<mat.length;r++) 13: sum=sum+mat[r][col]; 14: return sum; 15: } 16: public int sumofrow (int row){ // Compute sum of row 17: int sum=0; 18: for (int c=0;c<mat[0].length;c++) 19: sum=sum+mat[row][c]; 20: return sum; 21: } 22: } 36

37 // Build a magic square public class Magic { private int [][]mag; 1: public Magic(int size) { // size must be an odd number 2: mag = new int [size][size]; 3: // Create magic square 4: int i=0; 5: int j=size/2; 6: mag[i][j]=1; 7: for (int x=2;x<=size*size;x++) { 8: int oteki=i; 9: int otekj=j; 10: i=i-1; //move up one line 11: if (i<0) // if out of bounds 12: i=size-1; 13: j=j+1; //move right one column 14: if (j>=size) // if out of bounds 15: j=0; 16: if (mag[i][j]!= 0){ // if place is taken 17: i=oteki; // go back to former position 18: j=otekj; 19: i++; // move one line down 20: } // end of if 21: mag[i][j]=x; // found new place, insert number 22: } // end of for loop 23: } 24: public void displaymagic(){ 25: for (int i=0;i<mag.length;i++) { 26: for (int j=0;j<mag[0].length;j++) 27: System.out.print(mag[i][j]+"\t"); 28: System.out.println(); 29: } // of for loop 30: } 31: } : // Use class Magic 3: public class PlayMagic { 4: public static void main(string[] args) { 5: Magic m = new Magic(7); 6: m.displaymagic(); 7: } 8: } 37

38 1: // Sorting and searching an array 2: public class Arrayservice { 3: private int [] a; // the array's size is unknown 4: // constructor 5: // The size is determined by the client 6: public Arrayservice(int size) { 7: a = new int [size]; 8: } 9: // put element into place in the array 10: public void putelement( int element, int place ) 11: { 12: a [place] = element; 13: } 14: //print the array 15: public void print() 16: { 17: for ( int i=0; i<a.length; i++ ) 18: System.out.print (" " + a[i] ); 19: System.out.println(); 20: } 21: // find number in unsorted array, if not found return -1 22: public int searchunsorted (int element) { 23: for (int i = 0; i< a.length; i++) 24: if (a[i] == element) 25: return i; 26: return -1; 27: } 28: //sort the array 29: public void sort() { // uses selection sort 30: for ( int i=0; i<a.length; i++) 31: { 32: // find the position of the smallest value 33: // of the sublist a[i]... a[a.length - 1] 34: int min = i; 35: for (int j=i+1; j<a.length; j++ ) 36: if (a[j] < a[min]) 37: min = j; 38: // put the smallest value at the beginning 39: // of the sublist 40: swap (i,min); 41: } // of for loop 42: } 43: private void swap ( int i, int j) // is a private method 44: { 45: int temp = a[i]; 38

39 46: a[i] = a[j]; 47: a[j] = temp; 48: } 49: // find number in sorted array, if not found return -1 50: public int searchsorted (int element) { 51: for (int i = 0; i< a.length; i++) 52: if (a[i] == element) 53: return i; 54: else if (a[i] > element) 55: return -1; 56: return -1; // elemnet greater than last number in array 57: } 58: // find number in sorted array using binary search, if not found return -1 59: public int binarysearch (int element) { 60: int start = 0; 61: int end = a.length - 1; 62: while (start <= end) { 63: int mid = (start + end) /2; 64: if (element == a[mid]) 65: return mid; 66: else if(element < a[mid]) 67: end = mid - 1; 68: else 69: start = mid + 1; 70: } 71: return -1; 72: } 73: } 39

40 1: // search for a convict 2: import java.util.scanner; 3: public class Convicts { 4: public static void main(string[] args) { 5: Scanner input = new Scanner(System.in); 6: final int SIZE = 4; 7: Arrayservice ids = new Arrayservice(SIZE); 8: // read in ids of convicts and put in array 9: for (int i = 0; i < SIZE ; i++) { 10: System.out.println("Id please"); 11: int id = input.nextint(); 12: ids.putelement(id,i); 13: } 14: ids.print(); 15: // Read id of person and check if he is a convict 16: System.out.println(" New Id please"); 17: int suspect = input.nextint(); 18: 19: // Check if suspect was a convict 20: int answer = ids.searchunsorted(suspect); 21: if (answer == -1) 22: System.out.println("First arrest"); 23: else 24: System.out.println("Was arrested in the past"); 25: // Sort the array 26: ids.sort(); 27: ids.print(); 28: // Check if suspect was a convict using sorted array 29: answer = ids.searchsorted(suspect); 30: if (answer == -1) 31: System.out.println("First arrest"); 32: else 33: System.out.println("Was arrested in the past"); 34: // Check if suspect was a convict using sorted array - binary search 35: answer = ids.binarysearch(suspect); 36: if (answer == -1) 37: System.out.println("First arrest"); 38: else 39: System.out.println("Was arrested in the past"); 40: } 41: } 41

41 10 תרגיל כתבו מחלקה בשם. TwoDimArray משתנה המחלקה יהיה מערך דו-ממדי בו מספר השורות שווה למספר העמודות והינו מספר אי זוגי. הבנאי של המחלקה יקבל כפרמטר את מספר השורות/העמודות במערך ויבדוק אם המספר אי-זוגי. אם אינו אי-זוגי, יוסיף לו הבנאי 1 וכך יהפוך אותו לאי-זוגי. הבנאי יצור את המערך וימלא את התאים במספרים אקראיים בין 2 ל 122. המחלקה תגדיר את 3 השיטות הבאות: השיטה print)( public void תציג בחלון הפלט את המספרים המאוכסנים במערך. השיטה maxofrows)( public void תציג בחלון הפלט, עבור כל שורה במערך, את המספר הגבוה ביותר באותה שורה ובאיזה עמודה נמצא מספר זה )אם המספר מופיע יותר מפעם אחת, השיטה תבחר עמודה כלשהי בה מופיע המספר(. public int תחזיר את סכום המספרים הנמצאים על האלכסון הראשי של השיטה sumofdiagonal)( המערך. לדוגמה עבור מערך של 3X3. אם המערך מכיל את הנתונים הבאים : Line 0 max=5 in column 2 Line 1 max=20 in column 1 Line 2 max=8 in column 0 תציג השיטה maxofrows את התוצאות הבאות: והשיטה sumofdiagonal תחזיר את המספר 32 כי שווה 32. כתבו מחלקה בשם Tar10 ובה שיטה main היוצרת אוביקט של המחלקה TwoDimArray עם הפרמטר 1 ומפעילה על האוביקט את 3 השיטות של המחלקה. הגישו הדפסה של שתי המחלקות ושל חלון הפלט. שדכו דפים. 41

42 1: import java.io.*; 2: import java.util.scanner; 3: public class ReadFromFile // read name from a file 4: { 5: public static void main(string[] args) throws IOException 6: { 7: File myfile = new File("data.txt"); 8: Scanner myf = new Scanner(myFile); 9: String s; 10: s=myf.nextline(); 11: System.out.println("Hello " + s); 12: } 13: } : import java.io.*; 2: import java.util.scanner; 3: public class ReadFromFile1 // read names from a file till end of file 4: { 5: public static void main(string[] args) throws IOException 6: { 7: File myfile = new File("data.txt"); 8: Scanner myf = new Scanner(myFile); 9: String s; 10: while (myf.hasnext()){ 11: s=myf.nextline(); 12: System.out.println("Hello " + s); 13: } 14: } 15: } 42

43 1: import java.io.*; 2: import java.util.scanner; 3: public class WriteToFile // Read numbers, write their square root to a file 4: { 5: public static void main(string[] args) throws IOException 6: { 7: File infile = new File("inData.txt"); 8: Scanner inf = new Scanner(inFile); 9: 10: FileWriter outfile = new FileWriter("outData.txt") ; 11: PrintWriter outf = new PrintWriter(outFile); 12: 13: double num,numx; 14: while (inf.hasnext()){ 15: num=inf.nextdouble(); 16: numx=math.sqrt(num); 17: outf.println("sqrt of "+ num + " is "+ numx);; 18: } 19: outf.close(); 20: } 21: } : // Calculates student's grades 2: import java.io.*; 3: import java.util.scanner; 4: public class StudentGrades { 5: private int [] courses; 6: private int [] credits; 7: private int [] grades; 8: private int size; 9:// constructor receives the name of the file which holds the information about the student 10: public StudentGrades(String nameoffile) throws IOException{ 11: File myfile = new File(nameOfFile); 12: Scanner myf = new Scanner(myFile); 13: //create 100 cell arrays assuming no more than 100 courses were taken by student 14: courses = new int [100]; 15: credits=new int [100] ; 16: grades = new int [100] ; 17: int i =0; 18: while (myf.hasnext()){ 43

44 19: courses[i]=myf.nextint(); 20: credits[i]=myf.nextint(); 21: grades[i]=myf.nextint(); 22: i++; 23: } 24: size = i; 25: } 26: public double average(){ // Returns student's average grade 27: double sumcredits = 0, sum=0; 28: for (int i = 0; i<size ; i++){ 29: sumcredits += credits[i]; 30: sum +=credits[i] * grades[i]; 31: } 32: return sum / sumcredits; 33: } 34: public int sumofcredits(){ //Returns sum of credits student took 35: int sumcredits = 0; 36: for (int i = 0; i<size ; i++) 37: sumcredits += credits[i]; 38: return sumcredits; 39: } 40: //Calculate average of grades of courses taken in a specific deprtment 41: public double specificaverage(int dep){ 42: double sumcredits = 0, sum=0; 43: for (int i = 0; i<size ; i++) 44: if (courses[i]/100 == dep){ 45: sumcredits += credits[i]; 46: sum +=credits[i] * grades[i]; 47: } 48: if (sumcredits!=0) 49: return sum / sumcredits; 50: else 51: return -1; //if no courses were taken for the specific department, return -1 52: } 53: //returns sum of credits taken in a specific deprtment 54: public int specificsumofcredits (int dep){ 55: int sumcredits = 0; 56: for (int i = 0; i<size ; i++) 57: if (courses[i]/100 == dep) 58: sumcredits += credits[i]; 59: return sumcredits; 60: 61: } 62: } 44

45 1: // Use class StudentGrades 2: import java.io.*; 3: import java.util.scanner; 4: public class MyGrades { 5: public static void main(string[] args) throws IOException { 6: Scanner readin = new Scanner(System.in); 7: System.out.println("Hello dear student, what is the name of your file"); 8: System.out.println("and what would you like from us?"); 9: System.out.println("1 = to see the sum of your credits"); 10: System.out.println("2 = to see your average"); 11: System.out.println ("3 = to see the sum of your credits in a certain department (enter dep code)"); 12: System.out.println ("4 = to see your average in a certain department (enter dep code"); 13: String name = readin.next(); 14: int choice = readin.nextint(); 15: StudentGrades mystud = new StudentGrades(name); 16: double avg; 17: int sum, dep; 18: switch (choice){ 19: case 1: sum = mystud.sumofcredits(); 20: System.out.println("The sum is "+sum ) ; 21: break; 22: case 2: avg = mystud.average(); 23: System.out.println("The average is "+avg ) ; 24: break; 25: case 3: dep = readin.nextint(); 26: sum = mystud.specificsumofcredits(dep) ; 27: System.out.println("The sum is "+sum ) ; 28: break; 29: case 4: dep = readin.nextint(); 30: avg = mystud.specificaverage(dep); 31: System.out.println("The average is "+avg ) ; 32: break; 33: } 34: } 35: 36: } 45